

// source idl: com.b2b2c.cooperator.dao.idl.CooperatorDao.java

#ifndef COOPERATORDAO_STUB_4_WEB_H
#define COOPERATORDAO_STUB_4_WEB_H

#include <string>
#include <sstream>
#include "app_platform/cmd_obj.h"
#include "app_platform/cgi_stub_cntl.h"
#include "c2cent/base/basestub4web.h"
#include "app_platform/cntl_info.h"
#include "app_platform/intf_serializable.h"
#include "app_platform/intf_service_object.h"
#include "b2b2c/cooperator/ddo/cooperatorproddo_cooperator.h"	
#include "b2b2c/cooperator/ddo/cooperatorsubproddo_cooperator.h"	
#include "b2b2c/cooperator/ddo/cooperatorsetddo_cooperator.h"	
#include "b2b2c/cooperator/ddo/cooperatorsubaccountddo_cooperator.h"	
#include <set>	
#include "b2b2c/cooperator/ddo/cooperatorbaseinfoddo_cooperator.h"	
#include <vector>	
#include "b2b2c/cooperator/ddo/cooperatorlicenseddo_cooperator.h"	
#include "b2b2c/cooperator/ddo/cooperatormonitormodelddo_cooperator.h"	
#include "intf_cooperatordao.h"

namespace b2b2c
{
namespace cooperator
{
namespace dao
{

	const uint32_t COOPERATORDAO_CHECKCOOPERATORPASSWD_REQ_CMD_ID = 0xA0111803; ///检查合作伙伴密码信息请求类 请求命令号
	const uint32_t COOPERATORDAO_CHECKCOOPERATORPASSWD_RESP_CMD_ID = 0xA0118803; ///获取合作伙伴密码信息返回类 回应命令号
	

	const uint32_t COOPERATORDAO_DELETECOOPERATORMONITORMODEL_REQ_CMD_ID = 0xA0101807; /// 请求命令号
	const uint32_t COOPERATORDAO_DELETECOOPERATORMONITORMODEL_RESP_CMD_ID = 0xA0108807; /// 回应命令号
	

	const uint32_t COOPERATORDAO_GETCOOPERATORBASEINFO_REQ_CMD_ID = 0xA0111801; ///获取合作伙伴基本信息请求类 请求命令号
	const uint32_t COOPERATORDAO_GETCOOPERATORBASEINFO_RESP_CMD_ID = 0xA0118801; ///获取合作伙伴基本信息返回类 回应命令号
	

	const uint32_t COOPERATORDAO_GETCOOPERATORKEY_REQ_CMD_ID = 0xA0111804; ///获取合作伙伴数据加密Key请求类 请求命令号
	const uint32_t COOPERATORDAO_GETCOOPERATORKEY_RESP_CMD_ID = 0xA0118804; ///获取合作伙伴数据加密Key返回类 回应命令号
	

	const uint32_t COOPERATORDAO_GETCOOPERATORLICENSE_REQ_CMD_ID = 0xA0111802; ///获取合作伙伴许可证信息请求类 请求命令号
	const uint32_t COOPERATORDAO_GETCOOPERATORLICENSE_RESP_CMD_ID = 0xA0118802; ///获取合作伙伴许可证信息返回类 回应命令号
	

	const uint32_t COOPERATORDAO_GETCOOPERATORMONITORMODEL_REQ_CMD_ID = 0xA0111806; /// 请求命令号
	const uint32_t COOPERATORDAO_GETCOOPERATORMONITORMODEL_RESP_CMD_ID = 0xA0118806; /// 回应命令号
	

	const uint32_t COOPERATORDAO_GETCOOPERATORMONITORMODELLIST_REQ_CMD_ID = 0xA0111805; /// 请求命令号
	const uint32_t COOPERATORDAO_GETCOOPERATORMONITORMODELLIST_RESP_CMD_ID = 0xA0118805; /// 回应命令号
	

	const uint32_t COOPERATORDAO_SETCOOPERATORINFO_REQ_CMD_ID = 0xA0101805; ///从管理后台等其他业务同步过来的设置合作伙伴属性位等信息请求类 请求命令号
	const uint32_t COOPERATORDAO_SETCOOPERATORINFO_RESP_CMD_ID = 0xA0108805; ///从管理后台等其他业务同步过来的设置合作伙伴属性位等信息返回类 回应命令号
	

	const uint32_t COOPERATORDAO_SETCOOPERATORPASSWD_REQ_CMD_ID = 0xA0101802; ///设置合作伙伴密码信息请求类 请求命令号
	const uint32_t COOPERATORDAO_SETCOOPERATORPASSWD_RESP_CMD_ID = 0xA0108802; ///设置合作伙伴密码信息返回类 回应命令号
	

	const uint32_t COOPERATORDAO_SETCOOPERATORPRO_REQ_CMD_ID = 0xA0101804; ///支付物流系统设置卖家的次日达，货到付款等属性位请求类 请求命令号
	const uint32_t COOPERATORDAO_SETCOOPERATORPRO_RESP_CMD_ID = 0xA0108804; ///支付物流系统设置卖家的次日达，货到付款等属性位返回类 回应命令号
	

	const uint32_t COOPERATORDAO_UPDATECOOPERATORBASEINFO_REQ_CMD_ID = 0xA0101801; ///更新【新增和修改】合作伙伴基本信息请求类 请求命令号
	const uint32_t COOPERATORDAO_UPDATECOOPERATORBASEINFO_RESP_CMD_ID = 0xA0108801; ///更新【新增和修改】合作伙伴基本信息返回类 回应命令号
	

	const uint32_t COOPERATORDAO_UPDATECOOPERATORLICENSE_REQ_CMD_ID = 0xA0101803; ///更新【新增和修改】合作伙伴许可证信息请求类 请求命令号
	const uint32_t COOPERATORDAO_UPDATECOOPERATORLICENSE_RESP_CMD_ID = 0xA0108803; ///更新【新增和修改】合作伙伴许可证信息返回类 回应命令号
	

	const uint32_t COOPERATORDAO_UPDATECOOPERATORMONITORMODEL_REQ_CMD_ID = 0xA0101806; /// 请求命令号
	const uint32_t COOPERATORDAO_UPDATECOOPERATORMONITORMODEL_RESP_CMD_ID = 0xA0108806; /// 回应命令号
	


	const uint16_t COOPERATORDAO_MAX_PROTOCAL_VERSION = 2; //>平台支持的最大协议版本号

///////////////////////////// STRUCTS /////////////////////////////////////////////////
	/**
	 *
 	 * 检查合作伙伴密码信息请求类
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CCheckCooperatorPassWdReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint64_t cooperatorId;
		std::string cooperatorPassword;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_CHECKCOOPERATORPASSWD_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & cooperatorId;
			bs & cooperatorPassword;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 获取合作伙伴密码信息返回类
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CCheckCooperatorPassWdResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_CHECKCOOPERATORPASSWD_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CDeleteCooperatorMonitorModelReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t cooperatorId;
		uint32_t modelId;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_DELETECOOPERATORMONITORMODEL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & cooperatorId;
			bs & modelId;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CDeleteCooperatorMonitorModelResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_DELETECOOPERATORMONITORMODEL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 获取合作伙伴基本信息请求类
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CGetCooperatorBaseInfoReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint64_t cooperatorId;
		std::string inReserve;
		std::string errmsg;
		b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo cooperatorBaseInfoDdo;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_GETCOOPERATORBASEINFO_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & cooperatorId;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 获取合作伙伴基本信息返回类
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CGetCooperatorBaseInfoResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo cooperatorBaseInfoDdo;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_GETCOOPERATORBASEINFO_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			cooperatorBaseInfoDdo.Serialize(bs);
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 获取合作伙伴数据加密Key请求类
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CGetCooperatorKeyReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint64_t cooperatorId;
		std::string inReserve;
		std::string errmsg;
		std::string sCooperatorKey;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_GETCOOPERATORKEY_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & cooperatorId;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 获取合作伙伴数据加密Key返回类
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CGetCooperatorKeyResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string sCooperatorKey;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_GETCOOPERATORKEY_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & sCooperatorKey;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 获取合作伙伴许可证信息请求类
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CGetCooperatorLicenseReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint64_t cooperatorId;
		std::set<uint8_t > licenseType;
		std::string inReserve;
		std::string errmsg;
		std::vector<b2b2c::cooperator::ddo::CCooperatorLicenseDdo > cooperatorLicenseDdo;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_GETCOOPERATORLICENSE_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & cooperatorId;
			bs & licenseType;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 获取合作伙伴许可证信息返回类
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CGetCooperatorLicenseResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<b2b2c::cooperator::ddo::CCooperatorLicenseDdo > cooperatorLicenseDdo;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_GETCOOPERATORLICENSE_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & cooperatorLicenseDdo;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CGetCooperatorMonitorModelReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t cooperatorId;
		uint32_t modelId;
		std::string inReserve;
		std::string errmsg;
		b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo CooperatorMonitorModelDdo;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_GETCOOPERATORMONITORMODEL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & cooperatorId;
			bs & modelId;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CGetCooperatorMonitorModelResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo CooperatorMonitorModelDdo;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_GETCOOPERATORMONITORMODEL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			CooperatorMonitorModelDdo.Serialize(bs);
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CGetCooperatorMonitorModelListReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t cooperatorId;
		std::string inReserve;
		std::string errmsg;
		std::vector<b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo > CooperatorMonitorModelDdo;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_GETCOOPERATORMONITORMODELLIST_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & cooperatorId;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CGetCooperatorMonitorModelListResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo > CooperatorMonitorModelDdo;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_GETCOOPERATORMONITORMODELLIST_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & CooperatorMonitorModelDdo;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 从管理后台等其他业务同步过来的设置合作伙伴属性位等信息请求类
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CSetCooperatorInfoReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint64_t option;
		b2b2c::cooperator::ddo::CCooperatorSetDdo cooperatorSetDdo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_SETCOOPERATORINFO_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			cooperatorSetDdo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 从管理后台等其他业务同步过来的设置合作伙伴属性位等信息返回类
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CSetCooperatorInfoResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_SETCOOPERATORINFO_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 设置合作伙伴密码信息请求类
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CSetCooperatorPassWdReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint64_t cooperatorId;
		std::string cooperatorOldPassword;
		std::string cooperatorNewPassword;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_SETCOOPERATORPASSWD_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & cooperatorId;
			bs & cooperatorOldPassword;
			bs & cooperatorNewPassword;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 设置合作伙伴密码信息返回类
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CSetCooperatorPassWdResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_SETCOOPERATORPASSWD_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 支付物流系统设置卖家的次日达，货到付款等属性位请求类
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CSetCooperatorProReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint64_t option;
		b2b2c::cooperator::ddo::CCooperatorProDdo cooperatorProDdo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_SETCOOPERATORPRO_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			cooperatorProDdo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 支付物流系统设置卖家的次日达，货到付款等属性位返回类
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CSetCooperatorProResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_SETCOOPERATORPRO_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 更新【新增和修改】合作伙伴基本信息请求类
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CUpdateCooperatorBaseInfoReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo cooperatorBaseInfoDdo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_UPDATECOOPERATORBASEINFO_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			cooperatorBaseInfoDdo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 更新【新增和修改】合作伙伴基本信息返回类
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CUpdateCooperatorBaseInfoResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_UPDATECOOPERATORBASEINFO_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 更新【新增和修改】合作伙伴许可证信息请求类
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CUpdateCooperatorLicenseReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		b2b2c::cooperator::ddo::CCooperatorLicenseDdo cooperatorLicenseDdo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_UPDATECOOPERATORLICENSE_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			cooperatorLicenseDdo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 更新【新增和修改】合作伙伴许可证信息返回类
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CUpdateCooperatorLicenseResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_UPDATECOOPERATORLICENSE_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CUpdateCooperatorMonitorModelReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo CooperatorMonitorModelDdo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_UPDATECOOPERATORMONITORMODEL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > COOPERATORDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			CooperatorMonitorModelDdo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-01-21 10:53:06
 	 * @version 0
	 */	
	struct CUpdateCooperatorMonitorModelResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return COOPERATORDAO_UPDATECOOPERATORMONITORMODEL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	class CCooperatorDaoStub4Web : public c2cent::CBaseStub4Web, public ICooperatorDao	{
		public:
			uint32_t CheckCooperatorPassWd(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& cooperatorPassword,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			uint32_t DeleteCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				uint32_t modelId,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			uint32_t GetCooperatorBaseInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& inReserve,
				std::string& errmsg,
				b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo& cooperatorBaseInfoDdo,
				std::string& outReserve
			);
			uint32_t GetCooperatorKey(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& sCooperatorKey,
				std::string& outReserve
			);
			uint32_t GetCooperatorLicense(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::set<uint8_t >& licenseType,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<b2b2c::cooperator::ddo::CCooperatorLicenseDdo >& cooperatorLicenseDdo,
				std::string& outReserve
			);
			uint32_t GetCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				uint32_t modelId,
				const std::string& inReserve,
				std::string& errmsg,
				b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo& CooperatorMonitorModelDdo,
				std::string& outReserve
			);
			uint32_t GetCooperatorMonitorModelList(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo >& CooperatorMonitorModelDdo,
				std::string& outReserve
			);
			uint32_t SetCooperatorInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t option,
				const b2b2c::cooperator::ddo::CCooperatorSetDdo& cooperatorSetDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			uint32_t SetCooperatorPassWd(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& cooperatorOldPassword,
				const std::string& cooperatorNewPassword,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			uint32_t SetCooperatorPro(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t option,
				const b2b2c::cooperator::ddo::CCooperatorProDdo& cooperatorProDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			uint32_t UpdateCooperatorBaseInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo& cooperatorBaseInfoDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			uint32_t UpdateCooperatorLicense(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorLicenseDdo& cooperatorLicenseDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			uint32_t UpdateCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo& CooperatorMonitorModelDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
	};
	
	/**
	 *
 	 * 检查合作伙伴密码信息
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param uint64_t cooperatorId: 合作伙伴ID或合作伙伴子帐号ID，必填 				
		 *@param String cooperatorPassword: 合作伙伴密码（三次MD5加密），必填 				
		 *@param String inReserve: 请求保留字段 				
		 *@param String errmsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::CheckCooperatorPassWd(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& cooperatorPassword,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		 CCheckCooperatorPassWdReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.cooperatorPassword = cooperatorPassword;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_CHECKCOOPERATORPASSWD_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_CHECKCOOPERATORPASSWD_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCheckCooperatorPassWdResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 删除告警模版
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param uint32_t cooperatorId: 合作伙伴ID或合作伙伴子帐号ID，必填 				
		 *@param uint32_t modelId: 模版ID，必填 				
		 *@param String inReserve: 请求保留字段 				
		 *@param String errmsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::DeleteCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				uint32_t modelId,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		 CDeleteCooperatorMonitorModelReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.modelId = modelId;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_DELETECOOPERATORMONITORMODEL_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_DELETECOOPERATORMONITORMODEL_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 获取合作伙伴基本信息
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param uint64_t cooperatorId: 合作伙伴ID或合作伙伴子帐号ID，必填 				
		 *@param String inReserve: 请求保留字 				
		 *@param String errmsg: 错误信息 		
		 *@param CooperatorBaseInfoDdo cooperatorBaseInfoDdo: 合作伙伴基本信息 		
		 *@param String outReserve: 输出保留字 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::GetCooperatorBaseInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& inReserve,
				std::string& errmsg,
				b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo& cooperatorBaseInfoDdo,
				std::string& outReserve
	)
	{
		 CGetCooperatorBaseInfoReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.cooperatorBaseInfoDdo = cooperatorBaseInfoDdo;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_GETCOOPERATORBASEINFO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORBASEINFO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetCooperatorBaseInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			cooperatorBaseInfoDdo  = oResp.cooperatorBaseInfoDdo;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 获取合作伙伴数据加密Key
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param uint64_t cooperatorId: 合作伙伴ID或合作伙伴子帐号ID，必填 				
		 *@param String inReserve: 请求保留字段 				
		 *@param String errmsg: 错误信息 		
		 *@param String sCooperatorKey: 合作伙伴数据加密Key，长度32bytes；生成规则：合作伙伴当前密码三次MD5加密后的值 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::GetCooperatorKey(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& sCooperatorKey,
				std::string& outReserve
	)
	{
		 CGetCooperatorKeyReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.sCooperatorKey = sCooperatorKey;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_GETCOOPERATORKEY_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORKEY_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetCooperatorKeyResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			sCooperatorKey  = oResp.sCooperatorKey;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 获取合作伙伴许可证信息
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param uint64_t cooperatorId: 合作伙伴ID或合作伙伴子帐号ID，必填 				
		 *@param Set licenseType: 许可证类型，为空则为全部许可证列表 				
		 *@param String inReserve: 请求保留字段 				
		 *@param String errmsg: 错误信息 		
		 *@param Vector cooperatorLicenseDdo: 合作伙伴许可证信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::GetCooperatorLicense(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::set<uint8_t >& licenseType,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<b2b2c::cooperator::ddo::CCooperatorLicenseDdo >& cooperatorLicenseDdo,
				std::string& outReserve
	)
	{
		 CGetCooperatorLicenseReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.licenseType = licenseType;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.cooperatorLicenseDdo = cooperatorLicenseDdo;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_GETCOOPERATORLICENSE_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORLICENSE_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetCooperatorLicenseResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			cooperatorLicenseDdo  = oResp.cooperatorLicenseDdo;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 通过模版ID获取告警模版
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param uint32_t cooperatorId: 合作伙伴ID或合作伙伴子帐号ID，必填 				
		 *@param uint32_t modelId: 模版ID，必填 				
		 *@param String inReserve: 请求保留字段 				
		 *@param String errmsg: 错误信息 		
		 *@param CooperatorMonitorModelDdo CooperatorMonitorModelDdo: 告警模版 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::GetCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				uint32_t modelId,
				const std::string& inReserve,
				std::string& errmsg,
				b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo& CooperatorMonitorModelDdo,
				std::string& outReserve
	)
	{
		 CGetCooperatorMonitorModelReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.modelId = modelId;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.CooperatorMonitorModelDdo = CooperatorMonitorModelDdo;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_GETCOOPERATORMONITORMODEL_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORMONITORMODEL_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			CooperatorMonitorModelDdo  = oResp.CooperatorMonitorModelDdo;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 获取价格告警模版列表
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param uint32_t cooperatorId: 合作伙伴ID或合作伙伴子帐号ID，必填 				
		 *@param String inReserve: 请求保留字段 				
		 *@param String errmsg: 错误信息 		
		 *@param Vector CooperatorMonitorModelDdo: 告警模版列表 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::GetCooperatorMonitorModelList(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo >& CooperatorMonitorModelDdo,
				std::string& outReserve
	)
	{
		 CGetCooperatorMonitorModelListReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.CooperatorMonitorModelDdo = CooperatorMonitorModelDdo;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_GETCOOPERATORMONITORMODELLIST_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORMONITORMODELLIST_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetCooperatorMonitorModelListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			CooperatorMonitorModelDdo  = oResp.CooperatorMonitorModelDdo;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 从管理后台等其他业务同步过来的设置合作伙伴属性位等信息的接口
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param uint64_t option: 选项,暂未用 				
		 *@param CooperatorSetDdo cooperatorSetDdo: 合作伙伴属性位设置，包括合作伙伴ID、设置和取消属性值设置的参数（设置和取消的属性位不能冲突）等，必填 				
		 *@param String inReserve: 请求保留字 				
		 *@param String errmsg: 错误信息 		
		 *@param String outReserve: 输出保留字 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::SetCooperatorInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t option,
				const b2b2c::cooperator::ddo::CCooperatorSetDdo& cooperatorSetDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		 CSetCooperatorInfoReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.cooperatorSetDdo = cooperatorSetDdo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_SETCOOPERATORINFO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_SETCOOPERATORINFO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CSetCooperatorInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 设置合作伙伴密码信息
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param uint64_t cooperatorId: 合作伙伴ID，必填 				
		 *@param String cooperatorOldPassword: 合作伙伴老密码（三次MD5加密），必填 				
		 *@param String cooperatorNewPassword: 合作伙伴新密码（三次MD5加密），必填 				
		 *@param String inReserve: 请求保留字段 				
		 *@param String errmsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::SetCooperatorPassWd(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& cooperatorOldPassword,
				const std::string& cooperatorNewPassword,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		 CSetCooperatorPassWdReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.cooperatorOldPassword = cooperatorOldPassword;
			oReq.cooperatorNewPassword = cooperatorNewPassword;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_SETCOOPERATORPASSWD_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_SETCOOPERATORPASSWD_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CSetCooperatorPassWdResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 支付物流系统设置卖家的次日达，货到付款等属性位接口
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param uint64_t option: 选项,暂未用 				
		 *@param CooperatorProDdo cooperatorProDdo: 合作伙伴属性位设置，包括合作伙伴ID、设置和取消属性值设置的参数（设置和取消的属性位不能冲突），必填 				
		 *@param String inReserve: 请求保留字 				
		 *@param String errmsg: 错误信息 		
		 *@param String outReserve: 输出保留字 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::SetCooperatorPro(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t option,
				const b2b2c::cooperator::ddo::CCooperatorProDdo& cooperatorProDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		 CSetCooperatorProReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.cooperatorProDdo = cooperatorProDdo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_SETCOOPERATORPRO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_SETCOOPERATORPRO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CSetCooperatorProResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 更新【新增和修改】合作伙伴基本信息
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param CooperatorBaseInfoDdo cooperatorBaseInfoDdo: 合作伙伴基本信息，必填 				
		 *@param String inReserve: 请求保留字段 				
		 *@param String errmsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::UpdateCooperatorBaseInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo& cooperatorBaseInfoDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		 CUpdateCooperatorBaseInfoReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorBaseInfoDdo = cooperatorBaseInfoDdo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_UPDATECOOPERATORBASEINFO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_UPDATECOOPERATORBASEINFO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdateCooperatorBaseInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 更新【新增和修改】合作伙伴许可证信息
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param CooperatorLicenseDdo cooperatorLicenseDdo: 合作伙伴许可证信息，必填 				
		 *@param String inReserve: 请求保留字段 				
		 *@param String errmsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::UpdateCooperatorLicense(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorLicenseDdo& cooperatorLicenseDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		 CUpdateCooperatorLicenseReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorLicenseDdo = cooperatorLicenseDdo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_UPDATECOOPERATORLICENSE_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_UPDATECOOPERATORLICENSE_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdateCooperatorLicenseResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
	/**
	 *
 	 * 新增或者更新告警模版
	 *
		 *@param String machineKey: 机器码，必填 				
		 *@param String source: 调用来源，必填 				
		 *@param uint32_t sceneId: 场景id，必填 				
		 *@param CooperatorMonitorModelDdo CooperatorMonitorModelDdo: 告警模版，必填 				
		 *@param String inReserve: 请求保留字段 				
		 *@param String errmsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CCooperatorDaoStub4Web::UpdateCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo& CooperatorMonitorModelDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		 CUpdateCooperatorMonitorModelReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.CooperatorMonitorModelDdo = CooperatorMonitorModelDdo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
		
	    CCGI_STUB_CNTL->setPassport(
	        rCntlInfo.getOperatorUin(), 
	        rCntlInfo.getOperatorKey().c_str(),
	        rCntlInfo.getOperatorClientIP());
	
		if(const_cast<CCntlInfo&>(rCntlInfo).isRouteKeySet())	
			CCGI_STUB_CNTL->setUin(const_cast<CCntlInfo&>(rCntlInfo).getRouteKey());	
	    
	    if(CCGI_STUB_CNTL->putSvcObj(&oReq, 0) != 0)
	    {
			m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	    
	    // Send & Recv
		int iRetCode = 0;
		if((iRetCode = SendRecv()) != 0)
		{
			if(99 == iRetCode) // UDP & Need No Response
				return 0;
	
			std::stringstream oss;
			oss << m_lTimeout;
	        m_sErrMsg = "Send & Recv Timeout(";
			m_sErrMsg += oss.str();
			m_sErrMsg += "s) ";
			m_sErrMsg += CCGI_STUB_CNTL->GetLastErrMsg();
			return CCGI_STUB_CNTL->getCmd(); // Example : 0xf100
	    }
	    
		if(!m_poCmd->isValid(COOPERATORDAO_UPDATECOOPERATORMONITORMODEL_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_UPDATECOOPERATORMONITORMODEL_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    m_poCmd->getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdateCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
		    
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
		    
		return oResp.dwResult;
		}
		
}
}
}

#endif /* COOPERATORDAO_STUB_4_WEB_H */
